home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Freeware / Adobe Air 1.5 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / effects / Tween.as < prev    next >
Encoding:
Text File  |  2008-10-29  |  9.5 KB  |  347 lines
  1. package mx.effects
  2. {
  3.    import flash.events.EventDispatcher;
  4.    import flash.events.TimerEvent;
  5.    import flash.utils.Timer;
  6.    import flash.utils.getTimer;
  7.    import mx.core.UIComponentGlobals;
  8.    import mx.core.mx_internal;
  9.    import mx.events.TweenEvent;
  10.    
  11.    use namespace mx_internal;
  12.    
  13.    public class Tween extends EventDispatcher
  14.    {
  15.       mx_internal static const VERSION:String = "3.0.0.0";
  16.       
  17.       mx_internal static var activeTweens:Array = [];
  18.       
  19.       private static var interval:Number = 10;
  20.       
  21.       private static var timer:Timer = null;
  22.       
  23.       mx_internal static var intervalTime:Number = NaN;
  24.       
  25.       private var started:Boolean = false;
  26.       
  27.       private var previousUpdateTime:Number;
  28.       
  29.       public var duration:Number = 3000;
  30.       
  31.       private var id:int;
  32.       
  33.       private var arrayMode:Boolean;
  34.       
  35.       private var _isPlaying:Boolean = true;
  36.       
  37.       private var startValue:Object;
  38.       
  39.       public var listener:Object;
  40.       
  41.       private var userEquation:Function;
  42.       
  43.       mx_internal var needToLayout:Boolean = false;
  44.       
  45.       private var updateFunction:Function;
  46.       
  47.       private var _doSeek:Boolean = false;
  48.       
  49.       mx_internal var startTime:Number;
  50.       
  51.       private var endFunction:Function;
  52.       
  53.       private var endValue:Object;
  54.       
  55.       private var _doReverse:Boolean = false;
  56.       
  57.       private var _playheadTime:Number = 0;
  58.       
  59.       private var _invertValues:Boolean = false;
  60.       
  61.       private var maxDelay:Number = 87.5;
  62.       
  63.       public function Tween(param1:Object, param2:Object, param3:Object, param4:Number = -1, param5:Number = -1, param6:Function = null, param7:Function = null)
  64.       {
  65.          userEquation = defaultEasingFunction;
  66.          super();
  67.          if(!param1)
  68.          {
  69.             return;
  70.          }
  71.          if(param2 is Array)
  72.          {
  73.             arrayMode = true;
  74.          }
  75.          this.listener = param1;
  76.          this.startValue = param2;
  77.          this.endValue = param3;
  78.          if(!isNaN(param4) && param4 != -1)
  79.          {
  80.             this.duration = param4;
  81.          }
  82.          if(!isNaN(param5) && param5 != -1)
  83.          {
  84.             maxDelay = 1000 / param5;
  85.          }
  86.          this.updateFunction = param6;
  87.          this.endFunction = param7;
  88.          if(param4 == 0)
  89.          {
  90.             id = -1;
  91.             endTween();
  92.          }
  93.          else
  94.          {
  95.             Tween.addTween(this);
  96.          }
  97.       }
  98.       
  99.       mx_internal static function removeTween(param1:Tween) : void
  100.       {
  101.          removeTweenAt(param1.id);
  102.       }
  103.       
  104.       private static function addTween(param1:Tween) : void
  105.       {
  106.          param1.id = mx_internal::activeTweens.length;
  107.          mx_internal::activeTweens.push(param1);
  108.          if(!timer)
  109.          {
  110.             timer = new Timer(interval);
  111.             timer.addEventListener(TimerEvent.TIMER,timerHandler);
  112.             timer.start();
  113.          }
  114.          else
  115.          {
  116.             timer.start();
  117.          }
  118.          if(isNaN(mx_internal::intervalTime))
  119.          {
  120.             mx_internal::intervalTime = getTimer();
  121.          }
  122.          param1.mx_internal::startTime = param1.previousUpdateTime = mx_internal::intervalTime;
  123.       }
  124.       
  125.       private static function timerHandler(param1:TimerEvent) : void
  126.       {
  127.          var _loc6_:Tween = null;
  128.          var _loc2_:Boolean = false;
  129.          var _loc3_:Number = mx_internal::intervalTime;
  130.          mx_internal::intervalTime = getTimer();
  131.          var _loc4_:int;
  132.          var _loc5_:int = _loc4_ = int(mx_internal::activeTweens.length);
  133.          while(_loc5_ >= 0)
  134.          {
  135.             _loc6_ = Tween(mx_internal::activeTweens[_loc5_]);
  136.             if(_loc6_)
  137.             {
  138.                _loc6_.mx_internal::needToLayout = false;
  139.                _loc6_.mx_internal::doInterval();
  140.                if(_loc6_.mx_internal::needToLayout)
  141.                {
  142.                   _loc2_ = true;
  143.                }
  144.             }
  145.             _loc5_--;
  146.          }
  147.          if(_loc2_)
  148.          {
  149.             UIComponentGlobals.mx_internal::layoutManager.validateNow();
  150.          }
  151.          param1.updateAfterEvent();
  152.       }
  153.       
  154.       private static function removeTweenAt(param1:int) : void
  155.       {
  156.          var _loc4_:Tween = null;
  157.          if(param1 >= mx_internal::activeTweens.length || param1 < 0)
  158.          {
  159.             return;
  160.          }
  161.          mx_internal::activeTweens.splice(param1,1);
  162.          var _loc2_:int = int(mx_internal::activeTweens.length);
  163.          var _loc3_:int = param1;
  164.          while(_loc3_ < _loc2_)
  165.          {
  166.             _loc4_ = Tween(mx_internal::activeTweens[_loc3_]);
  167.             --_loc4_.id;
  168.             _loc3_++;
  169.          }
  170.          if(_loc2_ == 0)
  171.          {
  172.             mx_internal::intervalTime = NaN;
  173.             timer.reset();
  174.          }
  175.       }
  176.       
  177.       mx_internal function get playheadTime() : Number
  178.       {
  179.          return _playheadTime;
  180.       }
  181.       
  182.       public function stop() : void
  183.       {
  184.          if(id >= 0)
  185.          {
  186.             Tween.removeTweenAt(id);
  187.          }
  188.       }
  189.       
  190.       mx_internal function get playReversed() : Boolean
  191.       {
  192.          return _invertValues;
  193.       }
  194.       
  195.       mx_internal function set playReversed(param1:Boolean) : void
  196.       {
  197.          _invertValues = param1;
  198.       }
  199.       
  200.       public function resume() : void
  201.       {
  202.          _isPlaying = true;
  203.          mx_internal::startTime = mx_internal::intervalTime - _playheadTime;
  204.          if(_doReverse)
  205.          {
  206.             reverse();
  207.             _doReverse = false;
  208.          }
  209.       }
  210.       
  211.       public function setTweenHandlers(param1:Function, param2:Function) : void
  212.       {
  213.          this.updateFunction = param1;
  214.          this.endFunction = param2;
  215.       }
  216.       
  217.       private function defaultEasingFunction(param1:Number, param2:Number, param3:Number, param4:Number) : Number
  218.       {
  219.          return param3 / 2 * (Math.sin(Math.PI * (param1 / param4 - 0.5)) + 1) + param2;
  220.       }
  221.       
  222.       public function set easingFunction(param1:Function) : void
  223.       {
  224.          userEquation = param1;
  225.       }
  226.       
  227.       public function endTween() : void
  228.       {
  229.          var _loc1_:TweenEvent = new TweenEvent(TweenEvent.TWEEN_END);
  230.          var _loc2_:Object = mx_internal::getCurrentValue(duration);
  231.          _loc1_.value = _loc2_;
  232.          dispatchEvent(_loc1_);
  233.          if(endFunction != null)
  234.          {
  235.             endFunction(_loc2_);
  236.          }
  237.          else
  238.          {
  239.             listener.onTweenEnd(_loc2_);
  240.          }
  241.          if(id >= 0)
  242.          {
  243.             Tween.removeTweenAt(id);
  244.          }
  245.       }
  246.       
  247.       public function reverse() : void
  248.       {
  249.          if(_isPlaying)
  250.          {
  251.             _doReverse = false;
  252.             seek(duration - _playheadTime);
  253.             _invertValues = !_invertValues;
  254.          }
  255.          else
  256.          {
  257.             _doReverse = !_doReverse;
  258.          }
  259.       }
  260.       
  261.       mx_internal function getCurrentValue(param1:Number) : Object
  262.       {
  263.          var _loc2_:Array = null;
  264.          var _loc3_:int = 0;
  265.          var _loc4_:int = 0;
  266.          if(duration == 0)
  267.          {
  268.             return endValue;
  269.          }
  270.          if(_invertValues)
  271.          {
  272.             param1 = duration - param1;
  273.          }
  274.          if(arrayMode)
  275.          {
  276.             _loc2_ = [];
  277.             _loc3_ = int(startValue.length);
  278.             _loc4_ = 0;
  279.             while(_loc4_ < _loc3_)
  280.             {
  281.                _loc2_[_loc4_] = userEquation(param1,startValue[_loc4_],endValue[_loc4_] - startValue[_loc4_],duration);
  282.                _loc4_++;
  283.             }
  284.             return _loc2_;
  285.          }
  286.          return userEquation(param1,startValue,Number(endValue) - Number(startValue),duration);
  287.       }
  288.       
  289.       mx_internal function doInterval() : Boolean
  290.       {
  291.          var _loc2_:Number = NaN;
  292.          var _loc3_:Object = null;
  293.          var _loc4_:TweenEvent = null;
  294.          var _loc5_:TweenEvent = null;
  295.          var _loc1_:Boolean = false;
  296.          previousUpdateTime = mx_internal::intervalTime;
  297.          if(_isPlaying || _doSeek)
  298.          {
  299.             _loc2_ = mx_internal::intervalTime - mx_internal::startTime;
  300.             _playheadTime = _loc2_;
  301.             _loc3_ = mx_internal::getCurrentValue(_loc2_);
  302.             if(_loc2_ >= duration && !_doSeek)
  303.             {
  304.                endTween();
  305.                _loc1_ = true;
  306.             }
  307.             else
  308.             {
  309.                if(!started)
  310.                {
  311.                   _loc5_ = new TweenEvent(TweenEvent.TWEEN_START);
  312.                   dispatchEvent(_loc5_);
  313.                   started = true;
  314.                }
  315.                _loc4_ = new TweenEvent(TweenEvent.TWEEN_UPDATE);
  316.                _loc4_.value = _loc3_;
  317.                dispatchEvent(_loc4_);
  318.                if(updateFunction != null)
  319.                {
  320.                   updateFunction(_loc3_);
  321.                }
  322.                else
  323.                {
  324.                   listener.onTweenUpdate(_loc3_);
  325.                }
  326.             }
  327.             _doSeek = false;
  328.          }
  329.          return _loc1_;
  330.       }
  331.       
  332.       public function pause() : void
  333.       {
  334.          _isPlaying = false;
  335.       }
  336.       
  337.       public function seek(param1:Number) : void
  338.       {
  339.          var _loc2_:Number = mx_internal::intervalTime;
  340.          previousUpdateTime = _loc2_;
  341.          mx_internal::startTime = _loc2_ - param1;
  342.          _doSeek = true;
  343.       }
  344.    }
  345. }
  346.  
  347.